The CASE Statement

The VectorScript CASE statement lets you specify a list of alternative statements to be executed, associating a constant with each statement to identify it. When the CASE statement is executed it evaluates the controlling expression, and if the result matches one of the constants, it then executes the associated statement. An optional OTHERWISE clause allows a different statement to be executed if no other option was selected from the list of constants.

The general syntax for a CASE statement is:


CASE <control expression> OF
<constant>:<statement>;
<constant>:<statement>;
...
...
[OTHERWISE <statement>;]
END;

The control expression may evaluate to an INTEGER, CHAR, or BOOLEAN value. For example:


PROCEDURE Example_77;
VAR
j:INTEGER;
BEGIN
j:= Ord('C');
CASE j OF
49: Message('Number');
77: Message('Upper case alpha');
110: Message('Lower case alpha');
OTHERWISE Message('Out of range');
END;
END;
Run(Example_77);

The variable j evaluates to an INTEGER value, and this value is compared to the list of constants in the CASE statement. In the example, the value of j falls outside of the listed constants, so the OTHERWISE clause is executed.

CASE statements provide some flexibility when specifying constants. For instance, there may be applications of the CASE statement where several cases will need to execute the same code. Rather than use redundant options, the CASE statement lets you specify a comma delimited list of constants for a single CASE option:


PROCEDURE Example_78;
VAR
j:INTEGER;
BEGIN
j:= Ord('C');
CASE j OF
49: Message('Number');
58,59,60,61,62,63,64: Message('Non alpha printable character');
110: Message('Lower case alpha');
OTHERWISE Message('Out of range');
END;
END;
Run(Example_78);

Should the control expression evaluate to any of the values in the list, the associated statement will be executed.

For longer contiguous lists of constant values, the CASE statement also supports the use of ranges within the CASE statement constant specification. These ranges specify a contiguous list of constant values to be associated with a statement to be executed:


PROCEDURE Example_78;
VAR
j:INTEGER;
BEGIN
j:= Ord('C');
CASE j OF
48..57: Message('Number');
58,59,60,61,62,63,64: Message('Non alpha printable character');
65..90: Message('Upper case alpha');
97..122: Message('Lower case alpha');
OTHERWISE Message('Out of range');
END;
END;
Run(Example_78);

Ranges and comma delimited lists may be mixed for further flexibility in associating constants with an executable statement:


PROCEDURE Example_78;
VAR
j:INTEGER;
BEGIN
j:= Ord('C');
CASE j OF
48..57: Message('Number');
33..47,58..64,91..96:Message('Non alpha printable character');
65..90: Message('Upper case alpha');
97..122: Message('Lower case alpha');
128,133,134,168..170: Message('Special characters');
OTHERWISE Message('Out of range');
END;
END;
Run(Example_78);

In the example, it can be seen that the available methods of specifying CASE statement constants provide the ability to specify complex options for branching in a very concise format. Ranges and lists also work with the other supported constant types:


PROCEDURE Example_78;
VAR
j:CHAR;
BEGIN
j:= 'C';
CASE j OF
'0'..'9': Message('Number');
'A'..'Z': Message('Upper case alpha');
'a'..'z': Message('Lower case alpha');
OTHERWISE Message('Out of range');
END;
END;
Run(Example_78);

Like other statements, CASE statements can also support the use of compound statements as the controlled statement to be executed. Extending this concept, it is also possible to create nested CASE statements to handle even more complex branching in scripts:


PROCEDURE Example_78;
VAR
j:CHAR;
BEGIN
j:= 'C';
CASE j OF
'0'..'9': Message('Number');
'A'..'Z': Message('Upper case alpha');
'a'..'z': Message('Lower case alpha');
OTHERWISE BEGIN
CASE Ord(j) OF
33..47,58..64,91..96:Message('Non alpha printables');
128..159:Message('Accented characters');
168..170: Message('Special characters');
OTHERWISE Message('Out of range');
END;
END;
END;
END;
Run(Example_78);

Some cautions to be observed when using CASE statements:

Constant values in the CASE statement must have the same type as the value of the controlling expression.

Constant types may not be mixed in a single CASE statement.